Enhanced software components

ABSTRACT

The invention is a software structure for software components that adds greater flexibility to them. This structure is composed of the following parts: On Memory, Structure, On File Structure and On Memory On File Interface. This three parts are united into the same execution environment like a whole, performing functions like the older components but more complex than the older ones. The inner structure of an ESC is a three tier model that contains a piece of it always loaded in memory (On Memory Structure), the other (On File Structure) is loaded into pieces by a File Component Loader, and it works loading the pertinent data of the file extension. The On memory Structure and the On File Structure are communicated by an inner interface object (On Memory-On File interface) that provides a interface between the essential parts of an Enhanced Software Component establishing a two ways communication channel. This Interface is a common one for all ESC and it can be enriched in order to support specialized cases.

BACKGROUND OF INVENTION

[0001] 1. Field of the Invention

[0002] The present invention relates to the field of software components. Still more particularly, the present invention proposes a new development approach to software components.

[0003] 2. Discussion of Prior Art

[0004] Object has been a revolutionary way to make software. It has changed the paradigm of software module development into an easier way of develop and design software. It has changed concepts like linear programming, modular programming, cohesion and coupling, into concepts like encapsulation, polymorphism, abstraction y inheritance. Objects are conformed by methods and properties (and into a event driven environment, Events) where properties specifies object state and methods transformations over those properties i.e. over the object state. Each objects is instantiated by a class. The class contains all needed definitions (methods, properties, events) in order to instantiate an object). Classes can be constructed of another classes or inherit directly their properties and methods, and it can add more or override (polymorphism) them. All object oriented programming languages like Java, Smalltalk, C++ has implemented and supported these concepts.

[0005] The use of objects has becoming a common practice in software development, and today is the most used software paradigm. After some time of object oriented programming evolution, new needs appeared in the software development ground, needs like distributed execution of objects over a network, standards for classes interfaces, multiple interfaces for an object, transactional and queuing services, and the possibility of put classes instead of another of the same functionality and different implementation without recompile any part of the system, in order to exchange software classes or parts of it easily with software development workgroups, or buy this software to third party developers and put it into the system without any problem. All this needs converged in the same point, different component models that fulfill all the development requirements that exists in that moment.

[0006] A Software Component Model is a Software Services infrastructure and standards that maintains software classes generally in a network distribute environment. Examples of component models are CORBA, Enterprise JavaBeans, COM, COM+. These software classes coded in a very specific way attending to certain standards are called software components. Each software component perform a very specific task, and it can have a graphic interface or not. Examples of software components are, mail clients classes, socket abstraction layers, interface controls, business logic classes (of any kind of context, it would be classes like Report, User, Customer, Session, Customer Order, Document, etc). The software components must have a public interface that exposes certain functionality to the external world in order to be used for other components or Interfaces. Software Components have many advantages that are specific of a Component model, but generally in all cases of Software Component Models the advantages are the same. Each Software Component is a class into an software component container (.java or.dll files) or it can be intended like the whole container of classes. The software component infrastructure is based almost totally over Object Oriented Programming because the component actually are composed of classes. This Object Oriented Programming have disadvantages that makes the Software Component Model Weak in some areas. The theoretical basis of an object only can allow a set of properties and methods, and those are loaded into memory completely. An object isn't able to support any other type of media in its structure, making hard to model complex scenarios with few objects. There is the need to add to the different Component Models additional structure that provide support for complex objects, or gives versatility to the existing ones.

SUMMARY OF INVENTION

[0007] The present invention is a software structure for software components that adds greater flexibility to them. This structure is composed of the following parts: • On Memory Structure • On File Structure • On Memory On File InterfaceThis three parts are united into the same execution environment like a whole, performing functions like the older components but more complex than the older ones. The inner structure of an ESC is a three tier model that contains a piece of it always loaded in memory (On Memory Structure), the other (On File Structure) is loaded into pieces by a File Component Loader, and it works loading the pertinent data of the file extension. The On memory Structure and the On File Structure are communicated by an inner interface object (On Memory-On File interface) that provides a interface between the essential parts of an Enhanced Software Component establishing a two ways communication channel. This Interface is a common one for all ESC and it can be enriched in order to support specialized cases.

Objects and Advantages

[0008] Accordingly, several objects and advantages of our invention are:

[0009] a) Complex modeling Capabilities. The objects under this approach are likely to be used to model really complex problems including artificial intelligence, expert systems, etc.

[0010] b) It can use the Component Models existing in this moment in order to be implemented. This approach can be generalized to many different execution platforms of components existing in the software world.

[0011] c) Older Classes can be easily translated toward this new approach. Only it's necessary to construct or implement the specific On Memory On File Interface in order to add the new structural part to the classes.

[0012] d) Disrupt the lack of ability of conventional objects to include large data structures in order to comprehend more specialized models of reality in business case. It also can be applied to

[0013] e) Greater flexibility never seen before. The On Memory On File Interface can be changed in order to be updated to new data models, On File data (complex properties) or knowledge bases into the On File Structure.

[0014] f) Now with ESC exists a virtually unlimited number of data structures that a object can contains.

[0015] g) Mutating components. The methods on the On file Structure can be updated and changed in order to achieve different specific behavior of a component accomplishing a task. this results in an extremely dynamic component.

[0016] h) All Complex Management is transparent to the programmer, only a few methods of the On Memory On File are exposed in order to make the component more manageable.

BRIEF DESCRIPTION OF DRAWINGS Description of Drawings

[0017]FIG. 1 Example of a ordinary class.

[0018]FIG. 2 Structure of a ESC (Enhanced Software Component).

[0019]FIG. 3 Structure of On Memory and On File Structures.

[0020]FIG. 4 Structure of On Memory On File Interface.

List of Reference Numerals in Drawings

[0021]1.—List of Properties.

[0022]2.—List of Methods.

[0023]3.—On Memory Structure.

[0024]4.—On Memory On File Interface.

[0025]5.—On File Structure.

[0026]6.—On Memory Properties. Properties of common objects.

[0027]7.—On Memory Methods. Methods of common objects.

[0028]8.—Pointers to Complex functionality. Key links to data in On File Structure.

[0029]9.—Complex Data Storage Buffer. Buffer zone For complex data and functionality.

[0030]10.—On File Properties. Complex Data Types and structures or simple ones.

[0031]11.—Complex Functionality. High Processing Load Methods or Conditional\Adaptive Behavior.

[0032]12.—Knowledge Base. Accumulated knowledge of the component when the component is set to learn.

[0033]13.—Built In Interface OM-OF. Default interface for OM-OF communication.

[0034]14.—Extended Interface OM-OF. Default interface for OM-OF communication.

DETAILED DESCRIPTION Description of the Invention

[0035] Enhanced software components is an approach that take all the advantages of the different Component models and provides a richer way to improve their capabilities. This capabilities provides remarkable improvements over the common components that already exists in the software world. The enhanced software components includes the following concepts in order to understand them:

[0036] On Memory Structure:

[0037] Relates to the normal structure of an object loaded in memory (RAM) enriched with another elements. This structure is conformed by several on line properties that conform a part of the whole set of properties, they establish the state of the complex object along with On File properties; the structure contains on memory methods too, that define transformations over the state of the complex object. The On Memory structure contains several Pointers to complex functionality and a Complex Data Storage Buffer, it is a buffer area where the On File data of any type is loaded in order to be used by the On Memory Structure.

[0038] On File Structure:

[0039] This structure is similar in many ways to On Memory Structure it contains On File Properties that defines part of the state of the complex object, but they have a greater complexity than the On Memory ones. On file Structure Contains complex functionality and a knowledge base in order to learn and mutate behavior.

[0040] On Memory On File Interface:

[0041] This interface works like an abstraction layer between the implementation of the data types and complex functionality and knowledge base and the data that the On Memory Structure sees. It have a Built in interface that provides standard access to On File Data through the methods InitComplexRepository( ),GetComplexData( ) and PutComplexData( ). Additionally this built in interface can be enriched by another special methods depending of the required data types and functionality.

[0042] Pointers to Complex Functionality:

[0043] This pointer plays an essential role into the management of the complex dimension of the complex object. They points to the various complex functionality functions and procedures Embedded in the On file Structure.

[0044] Complex Data Storage Buffer:

[0045] This buffer hold any kind of data provided by the On Memory On File Interface. It is managed by the interface named before. This data came from the On File Structure, and placed in this place in order to be used by the On Memory structure.

[0046] On File Properties:

[0047] The On File properties deserves a special treatment because it have a greater complexity than the On Memory ones that have common data types. Here data structures like b-trees can be represented and abstracted from the On Memory Structure with the On Memory On File lnterface.Complex Functionality: The complex functionality includes all functions and procedures that have a complexity and dynamics greater than the On Memory Ones. Here the functionality can mutate or change in order to adapt to new execution sceneries and inputs or feedback of the system or other components. It is part of the On File Structure.

[0048] Knowledge Base:

[0049] This knowledge base keeps all the acquired knowledge data of the component operation through time. This base can be consulted or enriched through the On Memory On file Interface.

[0050] Built In Interface OM-OF:

[0051] It's the standard interface between the On Memory Structure and the On File Structure. It is composed by the following basic methods:

[0052] InitComplexRepository( ):

[0053] Initialize and get the proper pointers to the data in the repository in order to turn it into the On File Structure of an object.

[0054] GetComplexData( ):

[0055] Retrieves data from a repository to be used by the On Memory Structure.

[0056] PutComplexData( ):

[0057] writes data to a repository. (Mutate or change methods, add information to complex knowledge base)

[0058] ReleaseComplexRepository( ):

[0059] Release all memory references, pointers and buffers that belongs to a repository link. That link was established before by the InitCompled Repository( ) function.

[0060] Extended Interface OM-OF:

[0061] This interface is part of the On Memory On file Interface. It is conformed by several specific methods and data structures that provides abstract access to the particular complex data into the On File Structure.

[0062] An Enhanced Software Component is basically composed of a On Memory Structure (Provides the programmer interface), a On Memory—On file Interface (the methods of this interface are exposed by the On Memory Structure) and a On File Structure that stores all the complex and large data. The On Memory Structure includes the On Memory—On File Interface in order to manage (disk access, buffering, sorts, etc) the interaction with the On File structure. This On File Structure can be accessed by the standard interface of the custom made extended interface in order to support another special data types and structures. The On File Structure remain in disk and can take many forms (files or groups of files, raw data partitions, etc). When all this parts are united and coupled to function together conform a Enhanced Software Component

Operation of the Invention

[0063] A Software Enhanced Component when is instantiated a object is allocated in memory and a copy of the On File Structure is placed in disk, and main records of complex data, complex functionality and knowledge base are placed in the Complex Data Storage Buffer. All complex data is created at instantiation moment and can be modified, only Complex Functionality and Knowledge Base remains in the template file of the On File Structure that belongs to component. When a component is released or erased from memory the method ReleaseComplexRepository( ) gives the option of feed the On File Structure Knowledge Base and Complex Functionality adding the information gained during the object life in memory. All The structures and functionality are exposed through a public interface in the On Memory interface. This interface perform all specific task of the object itself and administrative tasks related to the On File Structure. When a object is used, all structures can be used like memory structures. All memory allocations and swapping will be managed by the object itself.

[0064] When a method of an object within a ESC is called the object verify the nature of the call within the function and make all the needed calls in order to access to On File Structures through the On Memory On File Interface. The OM-OF Interface get all structures and manipulates them in order to be loaded into the Complex Data Storage Buffer and be used by the On Memory Structure. The same occurs to the other parts of the ESC (Knowledge Base, Complex Functionality).

[0065] The Complex properties works in the same way. When a complex property must be read or wrote, the associated method with the operation (get or let) is ran like another method in the ESC, like a common execution of a common method into the ESC

Description and Operation of Alternative Embodiments

[0066] This type of software component can be used in the development of any type of software: military, commercial, web based, administrative, industrial, etc.

[0067] The following are only some clear examples:

[0068] An OCR Component to recognize a certain type of character.

[0069] A Component of metadata.

[0070] The first one is composed of simple properties like the coordinates of the area that will be recognized. There are complex properties too, like the recognizing pattern to follow (not a pattern descriptor like a number, but the pattern itself in the form of a b-tree). The OCR component contains a knowledge base in order to learn how to recognize certain types of pattern provided by a component training phase. The public interface of the component are functions like Recognize( ) and Training( ). The OM-OF Interface is the built in interface that access the On File Structure in the form of chunks of raw data and a Extended Interface that contains methods like GetPattern( ), WritePattern( ), TrainNeuralNet( ), GetOCRKnowHow( ), etc. The last functions are called from the implementation of the public interface within the On Memory Structure an its implementation must provide disk data management in order to load in memory the right portions of data when its needed. The recognition algorithm is totally dynamic, it can be changed or mutated in order to improve the results or change the semantics of the recognition. It can be implemented in the complex functionality section on the On File Structure.

[0071] In the other hand a metadata component stores a metadata model into its On File Structure in the form of a Complex Property. That metadata model refers to a database model that models a specific situation or micro world in a specific domain. The access methods to the data through the metamodel is made with the Complex Functionality. This approach allow to change the way of retrieve the data or preprocess it. Further, if the data model in the database is changed, the impact in the component will be minimal, only adjustment is needed in the content of the complex property that contains the metadata model.

Conclusion, Ramifications, and Scope of Invention

[0072] Thus, the reader will see that the present enhanced component paradigm is designed to fulfill requirements of versatility, unlimited number of properties and methods, ability to learn through time, which solves many limitations of existing components. This comprehensive component structure can be used in any software system independently of the objectives of the system itself. While our above description contains many specificities, these should not be construed as limitations to the scope of the invention, but rather as an exemplification of one preferred embodiment thereof.

[0073] Obviously, modifications and alterations will occur to others upon a reading and understanding of this specification such as, for example, several possible variations to the presented example structure (OCR) to include other example applications, several variations to the internal implementation of the architecture, especially to different choices to provide intelligence to a specific application. The description above is intended, however, to include all such modifications and alterations insofar as they come within the scope of the appended claims or the equivalents thereof. 

What is claimed is:
 1. In an object-oriented computer system, a method of generating software components, the method comprising the steps of: a) Loading a structure of an object to a memory means; b) Loading the file structure data by a file component loader; and c) Interafacing between the structure of an object and the file structure data by an interface object.
 2. The method of claim 1 wherein step c further comprises: c) interfacing between the structure of an object and the file structure data by an interface object using the methods InitComplexRepository( ), GetComplexData( ) and PutComplexData( ).
 3. The method of claim 1 wherein step a further comprises: a) said structure contains a plurality of pointers to complex functionalities and complex data storage buffers.
 4. The method of claim 1 wherein step b further comprises: b) Loading the file structure data by a file component loader which includes complex functionality and a knowledge base,
 5. The method of claim 1 wherein step c further comprises: c) interfacing between the structure of an object and the file structure data by an interface object consisting of the methods of linking memory references, pointers and buffers, geting the proper pointers to the data in the repository ofr loading into the structure of an object, retrieving data from a repository to be used by the structure, writing data to a repository, and releasing all memory references, pointers and buffers that belongs to a repository link.
 6. The method of claim 1 which includes step d comprising of: d. Maintaining a knowleged base that contains the acquired knowledge data of the component operation.
 7. The method of claim 1 wherein step a further comprises: a) said structure contains a plurality of pointers to complex functionalities and complex data storage buffers and said complex data storage buffers includes metadata models.
 8. The method of claim 1 wherein step a further comprises: a) said structure contains a plurality of pointers to complex functionalities and complex data storage buffers and said complex data storage buffers includes pattern recognization components.
 9. In an object-oriented computer system, a method of generating software components, the method comprising the steps of: a. Allocating an object in a memory means; b. Copying the structure to a memory means; c. Placing the records of complex data, complex functionality and knowledge base in the Complex Data Storage Buffer; d. Creating complex data at instantiation moment; e. Modifying complex data; f. Deciding whether to write complex data, complex functionality and knowledge base to a memory means; g. Exposing the structures and functionality through an interface that performs all specific task of the object itself and administrative tasks related to the structure; and h. Using a object in which all structures can be used like memory structures and all memory allocations and swapping will be managed by the object itself.
 10. In an object-oriented computer system, a device to generate software components comprising of: a) a load means for loading a structure of an object in a memory means; b) a load means for loading the file structure data by a file component loader; and c) an interface means for interafacing between the structure of an object and the file structure data by an interface object.
 11. The device of claim 10 in which: c) the interface means between the structure of an object and the file structure data by an interface object using the methods InitComplexRepository( ), GetComplexData( ) and PutComplexData( ).
 12. The device of claim 10 in which: a) said structure contains a plurality of pointers to complex functionalities and complex data storage buffers.
 13. The device of claim 10 in which: b) the load means loads the file structure data which includes complex functionality and a knowledge base by a file component loader,
 14. The device of claim 10 in which: c) the interface means between the structure of an object and the file structure data by an interface object using the methods of linking memory references, pointers and buffers, initializing and geting the proper pointers to the data in the repository ofr loading into the structure of an object, retrieving data from a repository to be used by the structure, writing data to a repository, and releasing all memory references, pointers and buffers that belongs to a repository link.
 15. The device of claim 10 in which: a knowleged base is maintained that contains the acquired knowledge data of the component operation.
 16. The device of claim 10 in which: said structure contains a plurality of pointers to complex functionalities and complex data storage buffers and said complex data storage buffers includes metadata models.
 17. The device of claim 10 in which: said structure contains a plurality of pointers to complex functionalities and complex data storage buffers and said complex data storage buffers includes pattern recognization components.
 18. In an object-oriented computer system, a device of generating software components comprising: a. An allocation means to allocate an object in a memory means; b. a writing means to copy structure to a memory means; c. The placing the records of complex data, complex functionality and knowledge base in the Complex Data Storage Buffer; d. The creating of complex data at instantiation moment; e. The modification of the complex data; f. Using a decision means to decide whether to write complex data, complex functionality and knowledge base to a memory means; g. The exposing of the structures and functionality through an interface that performs all specific task of the object itself and administrative tasks related to the structure; and h. The Using of a object in which all structures can be used like memory structures and all memory allocations and swapping will be managed by the object itself.
 19. A computer program product for generating software components, the computer program product comprising a computer usable medium having computer readable program code thereon, including: program code for Loading a structure of an object in a memory means; program code for loading the file structure data by a file component loader; and program code for Interfacing between the structure of an object and the file structure data by an interface object.
 20. The computer program product of claim 19 wherein the base component has interfaces and the program code for: interfacing between the structure of an object and the file structure data by an interface object using the methods InitComplexRepository( ), GetComplexData( ) and PutComplexData( ).
 21. The computer program product of claim 19 wherein the base component has interfaces and the program code for: having the structure containing a plurality of pointers to complex functionalities and complex data storage buffers.
 22. The computer program product of claim 19 wherein the base component has interfaces and the program code for: program code for loading the pertinent data of the file extension by a file component loader which includes complex functionality and a knowledge base,
 23. The computer program product of claim 19 wherein the base component has interfaces and the program code for: interfacing between the structure of an object and the pertinent data of the file extention by an interface object consisting of the methods of linking memory references, pointers and buffers, geting the proper pointers to the data in the repository ofr loading into the structure of an object, retrieving data from a repository to be used by the structure, writing data to a repository, and releasing all memory references, pointers and buffers that belongs to a repository link.
 24. The computer program product of claim 19 wherein the base component has interfaces and the program code for: Maintaining a knowleged base that contains the acquired knowledge data of the component operation.
 25. The computer program product of claim 19 wherein the base component has interfaces and the program code for: said structure to contains a plurality of pointers to complex functionalities and complex data storage buffers and said complex data storage buffers includes metadata models.
 26. The computer program product of claim 19 wherein the base component has interfaces and the program code for: said structure to contains plurality of pointers to complex functionalities and complex data storage buffers and said complex data storage buffers includes pattern recognization components.
 27. The computer program product of claim 19 wherein the base component has interfaces and the program code for: a. Allocating an object in a memory means; b. Copying the structure to a memory means; c. Placing the records of complex data, complex functionality and knowledge base in the Complex Data Storage Buffer; d. Creating complex data at instantiation moment; e. Modifying complex data; f. Deciding whether to write complex data, complex functionality and knowledge base to a memory means; g. Exposing the structures and functionality through an interface that performs all specific task of the object itself and administrative tasks related to the structure; and h. Using a object in which all structures can be used like memory structures and all memory allocations and swapping will be managed by the object. 